package com.ycrlkj.android.modulesbase.libbase.utils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.blankj.utilcode.util.StringUtils;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public final class HelperUtil {

    /**
     * 获取对象所有属性和值
     */
    public static Map<String, String> printAllMembers(Object obj){
        Map<String, String> map = new HashMap<>();
        Class cls = obj.getClass();
        while (cls != null && cls != Object.class){
            Field[] fields = cls.getDeclaredFields();
            for (Field fd : fields) {
                if (!fd.isAccessible()) {
                    fd.setAccessible(true);
                }
                try {
                    map.put(fd.getName(), fd.get(obj).toString());
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }

            cls = cls.getSuperclass();
        }
        return map;
    }

    /**
     * 阿里云iconfig.ttf自动转string 的xml文件 字符串列表
     */
    public static void iconfontToResource(String jsonPath, String sqlPath) throws Exception {

        //String data = readFile("D:/iconfont.json");
        String data = readFile(jsonPath);

        JSONObject jsonObj = JSONObject.parseObject(data);

        JSONArray arr = jsonObj.getJSONArray("glyphs");

        for (Object o : arr) {
            JSONObject item = (JSONObject) o;
            String font_class = item.getString("font_class");
            String unicode = item.getString("unicode");
            String itemStr = "<string name=\"" + font_class + "\">&#x" + unicode + ";</string> \n";
            //writeFile(itemStr, "D:/icon.text");
            writeFile(itemStr, sqlPath);
        }
    }

    /**
     * 写入文件
     */
    public static void writeFile(String content, String path) throws IOException {
        File file;
        file = new File(path);
        if (!file.exists()) {
            file.createNewFile();
        }
        FileWriter fileWriter = new FileWriter(file, true);
        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
        bufferedWriter.write(content);
        bufferedWriter.close();
    }

    public static String readFile(String path) {
        File file = new File(path);
        BufferedReader reader = null;
        StringBuilder lastStr = new StringBuilder();
        try {
            // System.out.println("以行为单位读取文件内容，一次读一行");
            reader = new BufferedReader(new FileReader(file));
            String tempString = null;
            int line = 1;
            // 一次读一行，直到读入null为文件结束
            while ((tempString = reader.readLine()) != null) {
                System.out.println("line " + line + ": " + tempString);
                lastStr.append(tempString);
                line++;
            }
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e1) {
                    System.out.println("关闭文件发生错误, ");
                    e1.printStackTrace();
                }
            }
        }
        return lastStr.toString();
    }

    public static Map<String, Object> javaEntity2Map(Object entity) {
        return JSON.parseObject(JSON.toJSONString(entity), Map.class);
    }

    /**
     * 字符串转换成为16进制(无需Unicode编码)
     */
    public static String str2HexStr(String str) {
        char[] chars = "0123456789ABCDEF".toCharArray();
        StringBuilder sb = new StringBuilder("");
        byte[] bs = str.getBytes();
        int bit;
        for (byte b : bs) {
            bit = (b & 0x0f0) >> 4;
            sb.append(chars[bit]);
            bit = b & 0x0f;
            sb.append(chars[bit]);
        }
        return sb.toString().trim();
    }

    /**
     * 16进制的字符串转成字节数组
     **/
    public static byte[] hexStr2byteArr(String hexString) {
        hexString = hexString.toLowerCase();
        final byte[] byteArray = new byte[hexString.length() / 2];
        int k = 0;
        for (int i = 0; i < byteArray.length; i++) {
            byte high = (byte) (Character.digit(hexString.charAt(k), 16) & 0xff);
            byte low = (byte) (Character.digit(hexString.charAt(k + 1), 16) & 0xff);
            byteArray[i] = (byte) (high << 4 | low);
            k += 2;
        }
        return byteArray;
    }

    /**
     * 16进制的字符串转成asc字符
     **/
    public static String hexStr2str(String hexStr) {
        String str = "0123456789ABCDEF";
        char[] hexs = hexStr.toCharArray();
        byte[] bytes = new byte[hexStr.length() / 2];
        int n;
        for (int i = 0; i < bytes.length; i++) {
            n = str.indexOf(hexs[2 * i]) * 16;
            n += str.indexOf(hexs[2 * i + 1]);
            bytes[i] = (byte) (n & 0xff);
        }
        return new String(bytes);
    }

    /**
     * 是否是有效的日期格式
     *
     * @param str 时间字符串
     * @return boolean
     */
    public static boolean isValidDate(String str) {

        boolean convertSuccess = true;

        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            //--代码备份: 时间转换严格模式
            //设置lenient为false, 严格模式, 否则SimpleDateFormat 2020-02-29 会被接受并转换成 2020-03-01
            format.setLenient(false);
            format.parse(str);
        } catch (ParseException e) {//如果throw java.text.ParseException 或者 NullPointerException，就说明格式不对
            e.printStackTrace();
            convertSuccess = false;
        }
        return convertSuccess;
    }

    /**
     * 检测str是否包含s, 如果包含就删除s, 返回删除后的字符串
     *
     * @param str 用 逗号 分隔的 string 字符串str
     * @param s   目标字符串
     * @return 删除 s 后的字符串
     */
    public static String reomveContain(String str, String s) {

        if (StringUtils.isEmpty(str)) {
            return "";
        }

        if (StringUtils.isEmpty(s)) {
            return str;
        }

        String[] arr = str.split(",");//转数组

        StringBuilder sb = new StringBuilder();

        for (String ss : arr) {
            //如果 不是空 且 不等于s 加入list
            if (!StringUtils.isEmpty(ss) && !s.equals(ss)) {
                sb.append(ss).append(",");
            }
        }

        return sb.toString();
    }

    /**
     * 将obj(list, arr, map) 用指定分隔符 连接成 字符串, 空元素会被去除
     *
     * @param obj        可遍历型对象(list, arr)
     * @param s          分隔符
     * @param deleteEndS 末尾的分隔符是否创建
     */
    public static String objJoin(Object obj, String s, boolean deleteEndS) {

        StringBuilder sb = new StringBuilder();

        if (obj instanceof List<?>) {

            for (int i = 0; i < ((List<?>) obj).size(); i++) {

                String os = ((List<?>) obj).get(i).toString();

                if (!StringUtils.isEmpty(os)) {
                    //如果要求结尾不加分隔符, 并且当前循环是最后一个循环, 则不加 分隔符
                    if (deleteEndS && i == ((List<?>) obj).size() - 1) {
                        sb.append(os);
                    } else {
                        sb.append(os).append(s);
                    }
                }
            }

        }

        if (obj instanceof Object[]) {

            for (int i = 0; i < ((Object[]) obj).length; i++) {

                String os = ((Object[]) obj)[i].toString();

                if (!StringUtils.isEmpty(os)) {
                    //如果要求结尾不加分隔符, 并且当前循环是最后一个循环, 则不加 分隔符
                    if (deleteEndS && i == ((Object[]) obj).length - 1) {
                        sb.append(os);
                    } else {
                        sb.append(os).append(s);
                    }
                }
            }

        }

        return sb.toString();
    }

    /**
     * 将list 用指定分隔符 连接成 字符串
     * 空元素会被去除
     *
     * @param list       字符串list
     * @param s          分隔符
     * @param deleteEndS 末尾的分隔符是否创建
     */
    public static String join(List<String> list, String s, boolean deleteEndS) {

        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < list.size(); i++) {

            String ss = list.get(i);

            if (!StringUtils.isEmpty(ss)) {
                //如果要求结尾不加分隔符, 并且当前循环是最后一个循环, 则不加 分隔符
                if (deleteEndS && i == list.size() - 1) {
                    sb.append(ss);
                } else {
                    sb.append(ss).append(s);
                }
            }
        }

        return sb.toString();
    }

    /**
     * 将数组 用指定分隔符 连接成 字符串
     * 空元素会被去除
     *
     * @param arr        字符串数组
     * @param s          分隔符
     * @param deleteEndS 末尾的分隔符是否创建
     */
    public static String join(String[] arr, String s, boolean deleteEndS) {

        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < arr.length; i++) {

            String ss = arr[i];

            if (!StringUtils.isEmpty(ss)) {
                //如果要求结尾不加分隔符, 并且当前循环是最后一个循环, 则不加 分隔符
                if (deleteEndS && i == arr.length - 1) {
                    sb.append(ss);
                } else {
                    sb.append(ss).append(s);
                }
            }
        }

        return sb.toString();
    }

    /**
     * List强制类型转换
     */
    public static <T> List<T> castList(Object obj, Class<T> clazz) {
        List<T> result = new ArrayList<T>();
        if (obj instanceof List<?>) {
            for (Object o : (List<?>) obj) {
                result.add(clazz.cast(o));
            }
            return result;
        }
        return null;
    }

    /**
     * String数组去空
     */
    public static String[] removeBlank(String[] arr) {
        List<String> list = new ArrayList<>();
        for (String str : arr) {
            if (!StringUtils.isEmpty(str)) {
                list.add(str);
            }
        }
        String[] strings = new String[list.size()];
        return list.toArray(strings);
    }

    /**
     * String数组去重
     */
    public static String[] removeDupl(String[] arr) {

        //数组转List 再转 set 再转回 数组, 由于 set 本身是唯一元素属性, 会自动去重
        //弊端: set 是无序, 去重后返回的数组 与 原数组顺序不一致
        Set<String> set = new HashSet<>(Arrays.asList(arr));
        return set.toArray(new String[0]);
    }

    /**
     * String数组 去重 去空(开销小, 会改变数组顺序)
     */
    public static String[] removeBlankAndRemoveDupl(String[] arr) {
        List<String> list = new ArrayList<>();
        for (String str : arr) {
            if (!StringUtils.isEmpty(str)) {
                list.add(str);
            }
        }

        Set<String> set = new HashSet<>(list);

        return set.toArray(new String[0]);
    }

    /**
     * 数组 去重 (开销大, 不会改变数组顺序)
     */
    public static String[] arrDistinct(String[] arr) {
        //java8 提供的新方法去重, 去重后顺序与原数组顺序一致(ctrl+shift+R搜索: 代码备份 也可找到其它说明)
        List<String> list = Arrays.stream(arr).distinct().collect(Collectors.toList());
        String[] arr1 = new String[list.size()];
        return list.toArray(arr1);
    }

    public static String dateFormat(Date date) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return format.format(date);
    }

    public static String dateFormat2date(Date date) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        return format.format(date);
    }

    public static Date str2date(String str) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = null;

        try {
            date = format.parse(str);
        } catch (Exception e) {
            throw new RuntimeException("字符串转日期错误");
        }

        return date;
    }

    /**
     * 字符串拷贝, 末尾加上 "_copy4位随机数"
     */
    public static String strCopy(String str) {
        if(StringUtils.isEmpty(str)){
            return "";
        }
        return str + "_copy" + new Random().nextInt(9999);
    }

    /**
     * 匹配字符串中最后一组连续数字 加1
     * 1, 如果有数字, 就最后一组数加1
     * 2, 如果没有数字, 就在末尾加 "_copy随机数"
     *
     */
    public static String strCopyIncrement(String str) {

        if(StringUtils.isEmpty(str)){
            return "";
        }

        //匹配字符串中非数字的字符, 把非数字的字符做为str.split()函数的分割符
        //示例: "1车间35号池0001号温度", 除了 1, 35, 0001 之外的其它字符都被当作了分隔符忽略掉了, str.split("[^0-9]")结果= [ "1", "35", "0001" ]
        String[] arr = str.split("[^0-9]");

        //如果字符串中不含有数字, 则返回原字符串加上 "_copy4位随机数"
        if (arr.length == 0) {
            return str + "_copy" + new Random().nextInt(9999);
        }

        String lastNumStr = arr[arr.length - 1];//取出最后一组数字字符串

        int incrementInt = Integer.parseInt(lastNumStr) + 1;

        //数字字符串补齐, 防止 IMEI0001 这种取出数字加1后 变成了 IMEI2, 需要取原长度与计算加1后的长度差 用0补齐
        String incrementStr = String.format("%0" + lastNumStr.length() + "d", incrementInt);

        return str.replaceAll(lastNumStr, incrementStr);
    }

    /**
     * 正则验证
     */
    public static boolean regTest(String regex, String str) {
        //邮箱验证表达式
        //String regEx = "^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(str);
        return m.matches();
    }


    /**
     * 正则 提取字符串中 符合条件的 子字符串
     */
    public static String getMatcher(String regex, String source) {
        String result = "";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(source);
        while (matcher.find()) {
            result = matcher.group(1);//只取第一组
        }
        return result;
    }

    //使用示例: 注意正则表达式中至少有一组括号, 如果不需要括号, 那就把括号写在最外层
    //String str = "uid=923933544/sid=DFS32DSFS";
    //String uid = getMatcher("uid=([\\d]+)", str);
    //String sid = getMatcher("sid=([0-9a-zA-Z]+)", str);

    //String url = "http://172.12.1.123/test.txt";
    //String regex = "(\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3})";
    //System.out.println(getMatcher(regex, url));


    /**
     * 下划线转驼峰
     */
    public static String lineToHump(String str) {
        str = str.toLowerCase();
        Pattern linePattern = Pattern.compile("_(\\w)");
        Matcher matcher = linePattern.matcher(str);
        StringBuffer sb = new StringBuffer();
        while (matcher.find()) {
            matcher.appendReplacement(sb, matcher.group(1).toUpperCase());
        }
        matcher.appendTail(sb);
        return sb.toString();
    }

    /**
     * 驼峰转下划线
     */
    public static String humpToLine(String str) {
        Pattern humpPattern = Pattern.compile("[A-Z]");
        Matcher matcher = humpPattern.matcher(str);
        StringBuffer sb = new StringBuffer();
        while (matcher.find()) {
            matcher.appendReplacement(sb, "_" + matcher.group(0).toLowerCase());
        }
        matcher.appendTail(sb);
        return sb.toString();
    }

    /**
     * 获取文件扩展名
     */
    public static String getcontentType(String FilenameExtension) {
        if (FilenameExtension.equalsIgnoreCase(".bmp")) {
            return "image/bmp";
        }
        if (FilenameExtension.equalsIgnoreCase(".gif")) {
            return "image/gif";
        }
        if (FilenameExtension.equalsIgnoreCase(".jpeg") ||
                FilenameExtension.equalsIgnoreCase(".jpg") ||
                FilenameExtension.equalsIgnoreCase(".png")) {
            return "image/jpeg";
        }
        if (FilenameExtension.equalsIgnoreCase(".html")) {
            return "text/html";
        }
        if (FilenameExtension.equalsIgnoreCase(".txt")) {
            return "text/plain";
        }
        if (FilenameExtension.equalsIgnoreCase(".vsd")) {
            return "application/vnd.visio";
        }
        if (FilenameExtension.equalsIgnoreCase(".pptx") ||
                FilenameExtension.equalsIgnoreCase(".ppt")) {
            return "application/vnd.ms-powerpoint";
        }
        if (FilenameExtension.equalsIgnoreCase(".docx") ||
                FilenameExtension.equalsIgnoreCase(".doc")) {
            return "application/msword";
        }
        if (FilenameExtension.equalsIgnoreCase(".xml")) {
            return "text/xml";
        }
        //PDF
        if (FilenameExtension.equalsIgnoreCase(".pdf")) {
            return "application/pdf";
        }
        return "image/jpeg";
    }


    /**
     * 输入流转换为xml字符串
     *
     * @param inputStream 输入流
     * @return xml 字符串
     */
    public static String convertToString(InputStream inputStream) throws IOException {
        ByteArrayOutputStream outSteam = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int len = 0;
        while ((len = inputStream.read(buffer)) != -1) {
            outSteam.write(buffer, 0, len);
        }
        outSteam.close();
        inputStream.close();
        return new String(outSteam.toByteArray(), "utf-8");
    }


    /***
     * MD5加密
     * @param str 原字符串
     * @return 加密后的字符串
     */
    public static String MD5(String str) {
        try {
            char[] hexChars = {'0', '1', '2', '3', '4', '5', '6', '7', '8',
                    '9', 'a', 'b', 'c', 'd', 'e', 'f'};
            byte[] bytes = str.getBytes();
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(bytes);
            bytes = md.digest();
            int j = bytes.length;
            char[] chars = new char[j * 2];
            int k = 0;
            for (byte b : bytes) {
                chars[k++] = hexChars[b >>> 4 & 0xf];
                chars[k++] = hexChars[b & 0xf];
            }
            return new String(chars);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            throw new RuntimeException("MD5加密出错！！+" + e);
        }
    }


    //字符串匹配函数
    public static boolean regex(String regex, String value) {
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(value);
        return m.find();
    }

    //将任意格式合法时间字符串转为 标准时间 字符串
    public static String str2dateStr(String str) throws ParseException {

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");


        //如果是 10 位时间戳
        if (regex("^\\d{10}$", str)) {
            Date date = new Date(Long.parseLong(str));

            return sdf.format(date);
        }


        //如果是 13 位时间戳
        if (regex("^\\d{13}$", str)) {
            Date date = new Date(Long.parseLong(str.substring(0, 9)));

            return sdf.format(date);
        }


        //如果是 2020-01-01 或者 2020/01/01
        if (regex("^\\d{4}[\\-|\\\\]\\d{2}[\\-|\\\\]\\d{2}$", str)) {
            str = str.replaceAll("[\\-|\\\\]", "-");//先都统一替换成 -
            SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
            //设置lenient为false, 严格模式, 否则SimpleDateFormat 2007/02/29会被接受并转换成2007/03/01
            ft.setLenient(false);
            Date date = ft.parse(str);

            return sdf.format(date);
        }


        //如果是 2020-01-01 00:00:00 或者 2020/01/01 00:00:00
        //即使是标准模式也要转换一次, 再转回来, 防止传入的是 错误时间: 比如 2020-13-32 61:61:61, 错误格式转换时会报错
        if (regex("^\\d{4}[\\-|\\\\]\\d{2}[\\-|\\\\]\\d{2}\\s\\d{2}\\:\\d{2}\\:\\d{2}$", str)) {

            str = str.replaceAll("[\\-|\\\\]", "-");//先都统一替换成 -
            SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            //设置lenient为false, 严格模式, 否则SimpleDateFormat 2007/02/29会被接受并转换成2007/03/01
            ft.setLenient(false);
            Date date = ft.parse(str);

            return sdf.format(date);
        }


        //如果是 2020
        //即使是标准模式也要转换一次, 再转回来, 防止传入的是 错误时间: 比如 2020-13-32 61:61:61, 错误格式转换时会报错
        if (regex("^\\d{4}$", str)) {

            SimpleDateFormat ft = new SimpleDateFormat("yyyy");
            //设置lenient为false, 严格模式, 否则SimpleDateFormat 2007/02/29会被接受并转换成2007/03/01
            ft.setLenient(false);
            Date date = ft.parse(str);

            return sdf.format(date);
        }


        //如果是 2020-01-01 00:00 或者 2020/01/01 00:00
        if (regex("^\\d{4}[\\-|\\\\]\\d{2}[\\-|\\\\]\\d{2}\\s\\d{2}\\:\\d{2}$", str)) {

            str = str.replaceAll("[\\-|\\\\]", "-");
            SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd HH:mm");
            //设置lenient为false, 严格模式, 否则SimpleDateFormat 2007/02/29会被接受并转换成2007/03/01
            ft.setLenient(false);
            Date date = ft.parse(str);

            return sdf.format(date);
        }


        //如果是 01-01 00:00:00 或者 01/01 00:00:00 转换成 当前年 + 月日时分秒
        if (regex("^\\d{2}[\\-|\\\\]\\d{2}\\s\\d{2}\\:\\d{2}\\:\\d{2}$", str)) {

            str = str.replaceAll("[\\-|\\\\]", "-");
            SimpleDateFormat ft = new SimpleDateFormat("MM-dd HH:mm:ss");
            //设置lenient为false, 严格模式, 否则SimpleDateFormat 2007/02/29会被接受并转换成2007/03/01
            ft.setLenient(false);
            Date date = ft.parse(str);

            //上面到 ft.parse(str)如果没报错, 那么 date 是从1970开始的, 需要转换成当前年

            SimpleDateFormat ft1 = new SimpleDateFormat("yyyy");

            String newY = ft1.format(new Date());

            return newY + str;
        }


        //如果是 01-01 00:00 或者 01/01 00:00转换成 当前年 + 月日时分秒
        if (regex("^\\d{2}[\\-|\\\\]\\d{2}\\s\\d{2}\\:\\d{2}$", str)) {

            str = str.replaceAll("[\\-|\\\\]", "-");
            SimpleDateFormat ft = new SimpleDateFormat("MM-dd HH:mm");
            //设置lenient为false, 严格模式, 否则SimpleDateFormat 2007/02/29会被接受并转换成2007/03/01
            ft.setLenient(false);
            Date date = ft.parse(str);

            //上面到 ft.parse(str)如果没报错, 那么 date 是从1970开始的, 需要转换成当前年

            SimpleDateFormat ft1 = new SimpleDateFormat("yyyy");

            String newY = ft1.format(new Date());

            return newY + str + ":00";
        }

        //如果是 00:00:00 转换成 当前年月日 + 时分秒
        if (regex("^\\d{2}\\:\\d{2}\\:\\d{2}$", str)) {

            SimpleDateFormat ft = new SimpleDateFormat("HH:mm:ss");
            //设置lenient为false, 严格模式, 否则SimpleDateFormat 2007/02/29会被接受并转换成2007/03/01
            ft.setLenient(false);
            Date date = ft.parse(str);

            //上面到 ft.parse(str)如果没报错, 那么 date 是从1970-01-01开始的, 需要转换成当前年月日

            SimpleDateFormat ft1 = new SimpleDateFormat("yyyy-MM-dd");

            String newYMD = ft1.format(new Date());

            return newYMD + " " + str;
        }


        //如果是 00:00 转换成 当前年月日 + 时分秒
        if (regex("^\\d{2}\\:\\d{2}$", str)) {

            SimpleDateFormat ft = new SimpleDateFormat("HH:mm");
            //设置lenient为false, 严格模式, 否则SimpleDateFormat 2007/02/29会被接受并转换成2007/03/01
            ft.setLenient(false);
            Date date = ft.parse(str);

            //上面到 ft.parse(str)如果没报错, 那么 date 是从1970开始的, 需要转换成当前年

            SimpleDateFormat ft1 = new SimpleDateFormat("yyyy-MM-dd");

            String newYMD = ft1.format(new Date());

            return newYMD + " " + str + ":00";
        }

        return null;
    }


}
